Manipulación de datos con Tidyverse

Javier Emmanuel Anguiano Pita

CONAHCYT-Universidad de Guadalajara

7 de enero de 2025

Agenda del día

  1. Flujo de trabajo para el análisis de datos.
  2. Manipulación de datos con Tidyverse.

Paquetes en R

Existen más de 20 mil funciones escritas por usuarios de R que están contenidas en paquetes (packages).

  • Hasta ahora solo hemos utilizado funciones que vienen incluidas de forma nativa en R base.
    • Los paquetes que han sido revisados de alguna forma por los usuarios de la comunidad de R se almacenan en el Comprehensive R Archive Network (CRAN).
    • Al momento de elaborar estas diapositivas la biblioteca del CRAN cuenta con 21,860 paquetes disponibles.

Paquetes en R

  • Un paquete en R es como un foco 💡
# Para usar un paquete primero debemos instalarlo
install.packages("package_name")
  # install.packages(package_name)

# Si queremos usar el paquete debemos invocarlo 
library(package_name)
  • La sintaxis es MUY importante
  • Los paquetes se descargan automáticamente de CRAN o algún repositorio en internet (avanzado).

Funciones en paquetes

  • Podemos evitar cargar un paquete en la memoria de R solo invocando una función: package_name::function().
# Podemos invocar funciones específicas
package_name::function()
  • Ventajas: Evitamos conflictos si hay funciones con el mismo nombre en varios paquetes. Dejamos evidencia para otros usuarios.
  • Desventajas: No es práctico si vamos a usar continuamente la función en nuestro código.

Tidyverse

¿Qué es Tidyverse?

El Tidyverse es una colección de paquetes de R diseñados para la administración y manipulación de datos ( data science ). Todos los paquetes comparten una misma filosofía de diseño, gramática y una estructura de datos subyacente (tidyverse.org).

Paquetes y funciones

Ve al Ejercicio 0 en la práctica guiada

Flujo de trabajo para el análisis de datos



🌈Tidyverse



Datos de ejemplo

Datos: palmerpenguins

  • En esta sesión vamos a trabajar con observaciones sobre pingüinos en el archipielago Palmer (Antartida)
  • El objetivo del dataset palmerpenguins es proveer muchos datos para hacer ejercicios de manipulación, exploración y análisis de datos.
  • Los datos fueron recopilados por Allison Horst y publicados con licencia abierta para su uso.
  • Contiene datos sobre especies, islas, largo y profundidad de la cresta, largo de las alas, etc. ?palmerpenguins.

Manipulación y Análisis de datos con R

Leyendo datos en R



Fuente: Elaboración propia.

Proyectos y directorios de trabajo

Cuando empiezas a programar para ti mismo:

  • Crea un folder dedicado a tu proyecto.
  • Inicia un nuevo proyecto de R: File>New Project >Existing Directory
  • Se creará un archivo con extensión .RProj.

Ventajas:

  • El directorio de trabajo se fijará automáticamente.
  • Automáticamente se recupera el historial de acciones y los objetos contenidos en el proyecto.
  • Es más fácil de reproducir los resultados (path relativo vs. absoluta)
getwd()
setwd()

Estructura de directorios del proyecto

Cada proyecto tiene su propia magia pero yo recomiendo usar la siguiente estructura de directorios:

nombre_proyecto 

├── README.md 
├── codigo 
│ ├── 1_preparacion_datos.Rmd 
│ ├── 2_manipulacion_datos.Rmd 
│ ├── 3_analisis_datos.Rmd 
│ ├── 3_estadistica_descriptiva.Rmd 
│ ├── 4_visualizacion.Rmd 
│ └── lib_func.R 
├── datos 
│ ├── originales 
│ └── procesados 
├── figuras 
└── nombre_proyecto.Rproj
  • Nunca guardes los datos manipulados sobre el archivo original.
  • Siempre incluye un README.md para saber que es lo que hace este proyecto.

Creación de estructura de directorios de trabajo

Podemos generar la estructura de carpetas directamente desde R:

###########################################################
# Esta función genera una estructura de directorios y
# archivos .Rmd en blanco para comenzar nuestro proyecto. 
#
# El único argumento de entrada es el path. 
###########################################################

plantilla_proyecto <- function(path) {
  # Verificar si el directorio base existe
  if (!dir.exists(path)) {
    stop(paste("El directorio", path, "no existe."))
  }
  
  # Cambiar el directorio de trabajo
  setwd(path)
  
  # Nombre del proyecto
  nombre_proyecto <- "Proyecto_1"
  
  # Crear carpeta principal del proyecto si no existe
  if (!dir.exists(nombre_proyecto)) {
    dir.create(nombre_proyecto)
  }
  
  # Definir estructura de carpetas (sin acentos)
  nombre_subcarpetas <- file.path(nombre_proyecto, c(
    "datos", "codigo", "figuras",    # Carpetas principales
    "datos/original", "datos/procesados" # Subcarpetas
  ))
  
  # Crear todas las carpetas de manera eficiente
  lapply(nombre_subcarpetas, dir.create, recursive = TRUE)
  
  # Crear los archivos dentro de la carpeta "codigo"
  carpeta_codigo <- file.path(nombre_proyecto, "codigo")
  
  # Verificar si la carpeta "codigo" existe antes de crear los archivos
  if (!dir.exists(carpeta_codigo)) {
    stop("La carpeta 'codigo' no existe.")
  }
  
  # Definir nombres de los archivos (sin acentos)
  file_names <- c(
    "1_preparacion_datos",  # Preparación de datos
    "2_manipulacion_datos", # Combinación de datos
    "3_est_descriptiva",    # Descriptivos
    "3_analisis_datos",     # Análisis
    "4_visualizacion"       # Visualización
  )
  
  # Crear las rutas completas para los archivos dentro de "codigo"
  file_paths <- file.path(carpeta_codigo, paste0(file_names, ".Rmd"))
  
  # Crear los archivos
  file.create(file_paths)
  
  # Crear un archivo adicional para funciones auxiliares
  file.create(file.path(carpeta_codigo, "funciones.R"))
  
  message("Estructura del proyecto creada exitosamente.")
}

Importación de datos

Función readr()

Para leer/exportar archivos de texto plano en R necesitamos:

  • Ubicación de los datos (path).
  • delimitador (separador de valores) de los datos p.ej.: ., .``; o |.


Leer desde archivo Escribir al archivo Separador
read_delim() write_delim() Todos. Definido por usuario
read_csv() write_csv() Comas
read_csv2() write_csv2() Punto y coma
read_tsv() write_tsv() Tabulación

Leer archivos de otros formatos

Para importar otros tipos de archivos podemos usar los siguientes paquetes:

  • readxl: Archivos en formato MS Excel (Usa Java)
  • haven: SPSS, Stata y SAS.
  • googlesheets4: Archivos de Google Sheets.
  • rvtest: Archivos HTML.

Ejemplo: Importando datos a R

Leer un archivo ubicado en la misma carpeta que tu script:

raw_tsv_data <- read_tsv("mi_archivo.tsv")


Leer un archivo ubicado en una carpeta diferente:

raw_csv_data <- read_csv("data/original/miarchivo.csv")


Podemos descargar datos directamente de internet:

# Fuente: https://catalog.data.gov/dataset/electric-vehicle-population-data
electric_vehicles <- read_csv("https://data.wa.gov/api/views/f6w7-q2d2/rows.csv")

Ve a los ejercicios 1, 2 y 3

Uso de tibbles en 🌈 Tidyverse

  • La mayoría de las funciones en Tidyverse producen resultados en objetos denominados tibbles.
  • Los tibbles son en escencia similares a los dataframe pero no son lo mismo:
    • Hacen menos cosas:
      • Nunca convierten caracteres en factores.
      • Nunca cambian el nombre de las variables.
      • Nunca asignan nombres a las filas.

Ejemplo de uso de tibbles

  • Ejemplos:
# install.packages("tidyverse")
# install.packages("datos")

library(tidyverse)
library(datos)

flores_df <- datos::flores
flores_tbl <- as_tibble(flores)

Selección y filtrado de datos

Uso del paquete dplyr

El paquete dplyr provee de una gramática para la manipulación de datos a partir de un conjunto consistente de verbos (funciones):

Verbo (función) Descripción
filter() Seleccionar filas que cumplan una o varias condiciones lógicas
select() Seleccionar o descartar columnas
rename() Cambiar el nombre de una columna
mutate() Transformar valores o crear una nueva columna
group_by() Agrupar datos en una o más columnas
arrange() Ordenar las filas de acuerdo al valor de las variables
summarize() Reduce un grupo de datos a una sola fila

Uso de filter()

Selecciona filas en un dataframe

  • Uso:
filter(nombre_objeto, condición)
  • Anteriormente usamos la sintáxis de R base para hacer algo similar:
imdb[imdb$duration_minutes == 132, c(1:13)] # R Base
df <- filter(imdb, duration_minutes == 132) # dplyr

Uso de select()

Seleccionar o descartar columnas en un dataframe.

  • Uso:
select(df, col1, col2)  # Selecciona columnas 1-2
select(df, -col3)  # Selecciona todas las columnas menos col3
  • Uso de funciones de selección especiales:
select(df, contains("col"))  # Seleccionar columnas que contienen "col"
  • Comparativa:
df[,c("nombre", "edad")]  # R Base
select(df, nombre, edad)  # Tidyverse

Ve a los ejercicios 4 y 5

Uso de la función mutate()

Transforma valores o crea columnas nuevas.

  • Uso:
mutate(df, colum_name = operación)

Añadir una nueva columna:

df$nueva_var <- var + 20  # R base
df <- mutate(df, nueva_var = var + 20) # Tidyverse

Uso de la función rename()

La usamos para renombrar columnas existentes.

  • Uso:
rename(df, new_col_name = old_col_name)
  • Ejemplo:
imdb$duration_minutes <- imdb$duracion_min # R Base
imdb <- rename(imdb, duracion_min = duration_minutes)  # dplyr

Ve a los ejercicios 6 y 7

El operador pipe

  • El símbolo %>% o |> (entonces o después) es un componente que encadena todas las operaciones de manipulación de datos.

  • Ventajas:

    • Nuestro código tiene una grámatica más amigable.
    • No es necesario anidar las llamadas a las funciones.
    • Es más sencillo eliminar/agregar operaciones en nuestro flujo de trabajo sin detener el código.

Ejemplo: Uso del operador pipe

# Nombre del objeto que usamos como insumo
imdb_manipulado <- imdb %>% 
  # Filtramos las películas que duran 132 minutos
  filter(duration_minutes == 132) %>% 
  # Conservamos unicamente el nombre, año y ranking
  select(name, year, rank, duration_minutes) %>% 
  # Creamos una nueva variable (year >=2000)
  mutate(siglo21 = ifelse(year >= 2000, 1, 0)) %>% 
  # Renombramos la variable duration_minutes
  rename(duracion_min = duration_minutes)
  • Notas:

    • df solo se menciona una vez al principio (seleccionar y guardar resultados de operaciones).
    • El código termina una vez que dejan de existir |> o %>%.

Ve al Ejercicio # 8

Tidy data en R

Tidy Data (Datos ordenados)

Nota

Los conjuntos de datos ordenados son fáciles de manipular, modelar y visualizar, y tienen una estructura específica: cada variable es una columna, cada observación es una fila, y cada tipo de unidad de observación es una tabla. (Wickham, 2014)

  • Así, los datos ordenados son datos rectangulares:

Formato de datos (Wide vs. Long)

  • En la vida real, los datos no los obtenemos en el formato o estructura que necesitamos para nuestros análisis.
  • Un mismo conjunto de datos puede expresarse en un formato ancho o largo:
    • En los datos en formato largo o tidy cada fila es una observación y cada columna es una variable.
    • Los datos en formato ancho pueden ser muy variables pero, en general, cada fila es un item, cada columna es una variable.

tidyr: Ordenando datos desordenados

El paquete tidyr contiene diversas funciones que pueden ser útiles para ordenar y transformar nuestros datos:

  • pivot_longer(): Útil para convertir datos en formato wide a long (Ordenar).
  • Sintáxis básica:
library(tidyr)

df %>%  
  pivot_longer(cols = c("var1", "var2",...),
               names_to = "col1_name", 
               values_to = "col2_name")
  • Donde:
    • cols: El nombre de las columnas a pivotear.
    • names_to: El nombre para la nueva columna de caractéres.
    • values_to: El nombre para la nueva columna de valores.
# Encuesta sobre religión y nivel de ingresos
data("relig_income")
relig_income

# Datos ordenados (formato largo)
df_tidy <- relig_income %>% 
  pivot_longer(-religion, 
               names_to = "income",
               values_to = "count")
# Aumentar el grado de complejidad con Billboard List
data("billboard")

df <- billboard %>% 
  pivot_longer(
    cols = starts_with("wk"), 
    names_to = "Semana",
    values_to = "Ranking",
    values_drop_na = TRUE
  )

tidyr: Ordenando datos desordenados

  • pivot_wider(): Útil para convertir datos en formato Long a Wide.
  • Sintáxis básica de uso:
library(tidyr)

df %>% 
  pivot_wider(names_from = var1,
              values_from = var2)
  • Donde:
    • names_from: La columna cuyos valores serán usados como nombres de columnas.
    • values_from: La columna cuyos valores serán usados como valores de las filas (celdas).

Ejemplo de uso pivot_wider()

# Transformar de datos en formato Long a Wide

data("fish_encounters")

fish_encounters <- fish_encounters %>% 
                      pivot_wider(names_from = station,
                                  values_from = seen)


# No se registra cuando no se vió al pez.
# Podemos intuir que esto es cuando existen NA's
## Completar valores faltantes con 0's

data("fish_encounters")

fish_encounters <- fish_encounters %>% 
                      pivot_wider(names_from = station,
                                  values_from = seen,
                                  values_fill = list(seen = 0))
View(fish_encounters)
# When missing use 0

Ve al Ejercicio #9

Fuente: Allison Hill

Fuente: Allison Hill

Resumiendo y combinando datos

Uso de la función group_by()

  • Es una función del paquete dplyr que se utiliza para agrupar datos.

  • Es útil cuando queremos realizar operaciones en algunos grupos dentro de un conjunto de datos.

  • Sintáxis básica:

library(dplyr)

df_agrupado <- df %>%  
                group_by(grupo1, grupo2, ...)
  • Donde:
    • df es un conjunto de datos rectangular.
    • grupo1, grupo2,... las columnas a partir de las cuales se quieren agrupar los datos.

Uso de la función summrize()

  • Esta función se utiliza para generar resumenes de datos.

  • Permite calcular estadísticas descriptivas (promedios, sumas, max, min, etc.) sobre un conjunto de datos agupado.

  • Sintáxis básica de uso:

resumen <- df %>% 
            group_by(categoria) %>% 
            summarize(estadistica = funcion(df_columna))
  • Donde:
    • df es un conjunto de datos agrupado con la función group_by().
    • estadistica: El nombre de la columna que contendrá el resumen de los datos.
    • funcion(): Cálculo que deseas aplicar p.ej. mean(), sum(), max().

Ejemplo de uso de funciones group_by() y summarize()

# Datos de ejemplo
datos <- tibble(
  categoria = c("A", "A", "B", "B", "C"),
  valor = c(10, 20, 30, 40, 50)
)

# Calcular resumen sin agrupar
resumen_general <- datos %>%
  summarize(promedio_valor = mean(valor))

# Calcular resumen agrupado
resumen_por_categoria <- datos %>%
  group_by(categoria) %>%
  summarize(
    promedio_valor = mean(valor),
    desv_est = sd(valor)
  )

Introducción a la unión de datos con dplyr

Uniones de datos

  • En la práctica las uniones (joins) de datos nos permiten combinar información entre varios objetos.
  • La única condición que deben cumplir los datos es que tengan al menos una columna en común.
  • En R existen diversos tipos de uniones:
    • Unión a la izquierda (left join).
    • Unión a la derecha (right join).
    • Unión completa (full join).
    • Unión interna (inner join).

Unión a la izquierda (left join)

En una unión a la izquierda de dos tablas L y R, la tabla resultante (llamemosla LR) contendrá todos los registros de la tabla L, pero solo los registros de R cuyas clales (ID) estén incluidas en L.

Unión a la derecha (right join)

En una unión a la derecha la tabla final contendrá todas las filas de R, pero sólo aquellas de L que tengan una clave coincidente. Nótese, que es posible reformular una unión a la derecha de L con R como una a la izquierda de R con L.

Unión interna (inner join)

En la unión interna, sólo los registros de L y R que tengan una clave igual aparecerán en la tabla final.

Unión completa (full join)

En la unión completa, la tabla resultante contendrá todas las filas de L y todas las de R, con independencia de que no exista una clave coincidente.

Uniones de datos usando R {base}

  • Para unir tablas de datos usando R {base} podemos usar la función merge().

    • Sintáxis de uso:
merge(
  x = df1
  y = df2,
  by = "var_id"
)
  • Donde:
    • df1 y df2 son las tablas de datos que queremos unir.
    • var_id es la variable en común a partir de la que unimos los datos.

Ejemplo de uso función merge()

# Ejemplo datos ensayo clínico

demographics <- data.frame(
  id = c("P1", "P2", "P3"),
  age = c(40, 54, 47),
  country = c("GER", "JPN", "BRA"),
  stringsAsFactors = FALSE
)
adverse_events <- data.frame(
  id = c("P1", "P1", "P3", "P4"),
  term = c("Headache", "Neutropenia", "Constipation", "Tachycardia"),
  onset_date = c("2020-12-03", "2021-01-03", "2020-11-29", "2021-01-27"),
  stringsAsFactors = FALSE
)
# Ejemplo Unión por la izquierda all.y (derecha)

df_merge <- merge(
  x = demographics,
  y = adverse_events,
  by = "id",
  all.x = TRUE
)

df_merge
# Ejemplo Unión completa

df_merge <- merge(
  x = demographics,
  y = adverse_events,
  by = "id",
  all = TRUE
)

df_merge

Ejemplo de uniones usando dplyr

  • En dplyr tenemos una función (verbo) para cada tipo de unión:
    • left_join().
    • right_join().
    • inner_join().
    • full_join().
# Ejemplo de uniones usando dplyr
library(dplyr)
left_join(demographics, adverse_events, by = "id")
inner_join(demographics, adverse_events, by = "id")
full_join(demographics, adverse_events, by = "id")

Ejemplo de unión con dplyr

  • En caso de que el nombre de las variables ID de las dos tablas no coincida, tendrás que pasar un vector nombrado como argumento de by.

  • Nombre y valor corresponden con la clave en la primera y segunda tabla, respectivamente.

right_join(demographics, adverse_events2, by = c("id" = "pat_id"))

Ve a los Ejercicios # 10 y # 11